home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2004 April / Gamestar_61_2004-04_dvdb.iso / DVDStar / Editace / hltp.exe / {app} / Source Code / Zoners Half-Life Tools / hlbsp / writebsp.cpp < prev   
C/C++ Source or Header  |  2002-11-09  |  8KB  |  287 lines
  1. #include "bsp5.h"
  2.  
  3. //  WriteClipNodes_r
  4. //  WriteClipNodes
  5. //  WriteDrawLeaf
  6. //  WriteFace
  7. //  WriteDrawNodes_r
  8. //  FreeDrawNodes_r
  9. //  WriteDrawNodes
  10. //  BeginBSPFile
  11. //  FinishBSPFile
  12.  
  13. // =====================================================================================
  14. //  WriteClipNodes_r
  15. // =====================================================================================
  16. static int      WriteClipNodes_r(node_t* node)
  17. {
  18.     int             i, c;
  19.     dclipnode_t*    cn;
  20.     int             num;
  21.  
  22.     if (node->planenum == -1)
  23.     {
  24.         num = node->contents;
  25.         free(node->markfaces);
  26.         free(node);
  27.         return num;
  28.     }
  29.  
  30.     // emit a clipnode
  31.     hlassume(g_numclipnodes < MAX_MAP_CLIPNODES, assume_MAX_MAP_CLIPNODES);
  32.  
  33.     c = g_numclipnodes;
  34.     cn = &g_dclipnodes[g_numclipnodes];
  35.     g_numclipnodes++;
  36.     if (node->planenum & 1)
  37.     {
  38.         Error("WriteClipNodes_r: odd planenum");
  39.     }
  40.     cn->planenum = node->planenum;
  41.     for (i = 0; i < 2; i++)
  42.     {
  43.         cn->children[i] = WriteClipNodes_r(node->children[i]);
  44.     }
  45.  
  46.     free(node);
  47.     return c;
  48. }
  49.  
  50. // =====================================================================================
  51. //  WriteClipNodes
  52. //      Called after the clipping hull is completed.  Generates a disk format
  53. //      representation and frees the original memory.
  54. // =====================================================================================
  55. void            WriteClipNodes(node_t* nodes)
  56. {
  57.     WriteClipNodes_r(nodes);
  58. }
  59.  
  60. // =====================================================================================
  61. //  WriteDrawLeaf
  62. // =====================================================================================
  63. static void     WriteDrawLeaf(const node_t* const node)
  64. {
  65.     face_t**        fp;
  66.     face_t*         f;
  67.     dleaf_t*        leaf_p;
  68.  
  69.     // emit a leaf
  70.     leaf_p = &g_dleafs[g_numleafs];
  71.     g_numleafs++;
  72.  
  73.     leaf_p->contents = node->contents;
  74.  
  75.     //
  76.     // write bounding box info
  77.     //      
  78.     VectorCopy(node->mins, leaf_p->mins);
  79.     VectorCopy(node->maxs, leaf_p->maxs);
  80.  
  81.     leaf_p->visofs = -1;                                   // no vis info yet
  82.  
  83.     //
  84.     // write the marksurfaces
  85.     //
  86.     leaf_p->firstmarksurface = g_nummarksurfaces;
  87.  
  88.     hlassume(node->markfaces != NULL, assume_EmptySolid);
  89.  
  90.     for (fp = node->markfaces; *fp; fp++)
  91.     {
  92.         // emit a marksurface
  93.         f = *fp;
  94.         do
  95.         {
  96.             g_dmarksurfaces[g_nummarksurfaces] = f->outputnumber;
  97.             hlassume(g_nummarksurfaces < MAX_MAP_MARKSURFACES, assume_MAX_MAP_MARKSURFACES);
  98.             g_nummarksurfaces++;
  99.             f = f->original;                               // grab tjunction split faces
  100.         }
  101.         while (f);
  102.     }
  103.     free(node->markfaces);
  104.  
  105.     leaf_p->nummarksurfaces = g_nummarksurfaces - leaf_p->firstmarksurface;
  106. }
  107.  
  108. // =====================================================================================
  109. //  WriteFace
  110. // =====================================================================================
  111. static void     WriteFace(face_t* f)
  112. {
  113.     dface_t*        df;
  114.     int             i;
  115.     int             e;
  116.  
  117.     if (    CheckFaceForHint(f) 
  118.         ||  CheckFaceForSkip(f) 
  119. #ifdef ZHLT_NULLTEX
  120.         ||  CheckFaceForNull(f)  // AJM 
  121. #endif
  122.        )
  123.     {
  124.         return;
  125.     }
  126.  
  127.     f->outputnumber = g_numfaces;
  128.  
  129.     df = &g_dfaces[g_numfaces];
  130.     hlassume(g_numfaces < MAX_MAP_FACES, assume_MAX_MAP_FACES);
  131.     g_numfaces++;
  132.  
  133.     df->planenum = f->planenum & (~1);
  134.     df->side = f->planenum & 1;
  135.     df->firstedge = g_numsurfedges;
  136.     df->numedges = f->numpoints;
  137.     df->texinfo = f->texturenum;
  138.     for (i = 0; i < f->numpoints; i++)
  139.     {
  140.         e = GetEdge(f->pts[i], f->pts[(i + 1) % f->numpoints], f);
  141.         hlassume(g_numsurfedges < MAX_MAP_SURFEDGES, assume_MAX_MAP_SURFEDGES);
  142.         g_dsurfedges[g_numsurfedges] = e;
  143.         g_numsurfedges++;
  144.     }
  145. }
  146.  
  147. // =====================================================================================
  148. //  WriteDrawNodes_r
  149. // =====================================================================================
  150. static void     WriteDrawNodes_r(const node_t* const node)
  151. {
  152.     dnode_t*        n;
  153.     int             i;
  154.     face_t*         f;
  155.  
  156.     // emit a node  
  157.     hlassume(g_numnodes < MAX_MAP_NODES, assume_MAX_MAP_NODES);
  158.     n = &g_dnodes[g_numnodes];
  159.     g_numnodes++;
  160.  
  161.     VectorCopy(node->mins, n->mins);
  162.     VectorCopy(node->maxs, n->maxs);
  163.  
  164.     if (node->planenum & 1)
  165.     {
  166.         Error("WriteDrawNodes_r: odd planenum");
  167.     }
  168.     n->planenum = node->planenum;
  169.     n->firstface = g_numfaces;
  170.  
  171.     for (f = node->faces; f; f = f->next)
  172.     {
  173.         WriteFace(f);
  174.     }
  175.  
  176.     n->numfaces = g_numfaces - n->firstface;
  177.  
  178.     //
  179.     // recursively output the other nodes
  180.     //      
  181.     for (i = 0; i < 2; i++)
  182.     {
  183.         if (node->children[i]->planenum == -1)
  184.         {
  185.             if (node->children[i]->contents == CONTENTS_SOLID)
  186.             {
  187.                 n->children[i] = -1;
  188.             }
  189.             else
  190.             {
  191.                 n->children[i] = -(g_numleafs + 1);
  192.                 WriteDrawLeaf(node->children[i]);
  193.             }
  194.         }
  195.         else
  196.         {
  197.             n->children[i] = g_numnodes;
  198.             WriteDrawNodes_r(node->children[i]);
  199.         }
  200.     }
  201. }
  202.  
  203. // =====================================================================================
  204. //  FreeDrawNodes_r
  205. // =====================================================================================
  206. static void     FreeDrawNodes_r(node_t* node)
  207. {
  208.     int             i;
  209.     face_t*         f;
  210.     face_t*         next;
  211.  
  212.     for (i = 0; i < 2; i++)
  213.     {
  214.         if (node->children[i]->planenum != -1)
  215.         {
  216.             FreeDrawNodes_r(node->children[i]);
  217.         }
  218.     }
  219.  
  220.     //
  221.     // free the faces on the node
  222.     //
  223.     for (f = node->faces; f; f = next)
  224.     {
  225.         next = f->next;
  226.         FreeFace(f);
  227.     }
  228.  
  229.     free(node);
  230. }
  231.  
  232. // =====================================================================================
  233. //  WriteDrawNodes
  234. //      Called after a drawing hull is completed
  235. //      Frees all nodes and faces
  236. // =====================================================================================
  237. void            WriteDrawNodes(node_t* headnode)
  238. {
  239.     if (headnode->contents < 0)
  240.     {
  241.         WriteDrawLeaf(headnode);
  242.     }
  243.     else
  244.     {
  245.         WriteDrawNodes_r(headnode);
  246.         FreeDrawNodes_r(headnode);
  247.     }
  248. }
  249.  
  250.  
  251. // =====================================================================================
  252. //  BeginBSPFile
  253. // =====================================================================================
  254. void            BeginBSPFile()
  255. {
  256.     // these values may actually be initialized
  257.     // if the file existed when loaded, so clear them explicitly
  258.     g_nummodels = 0;
  259.     g_numfaces = 0;
  260.     g_numnodes = 0;
  261.     g_numclipnodes = 0;
  262.     g_numvertexes = 0;
  263.     g_nummarksurfaces = 0;
  264.     g_numsurfedges = 0;
  265.  
  266.     // edge 0 is not used, because 0 can't be negated
  267.     g_numedges = 1;
  268.  
  269.     // leaf 0 is common solid with no faces
  270.     g_numleafs = 1;
  271.     g_dleafs[0].contents = CONTENTS_SOLID;
  272. }
  273.  
  274. // =====================================================================================
  275. //  FinishBSPFile
  276. // =====================================================================================
  277. void            FinishBSPFile()
  278. {
  279.     Verbose("--- FinishBSPFile ---\n");
  280.  
  281.     if (g_chart)
  282.     {
  283.         PrintBSPFileSizes();
  284.     }
  285.     WriteBSPFile(g_bspfilename);
  286. }
  287.